import java.util.*;
import java.io.*;

class Read // ⾃定义快速读⼊
{
    StringTokenizer st = new StringTokenizer("");
    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    String next() throws IOException
    {
        while(!st.hasMoreTokens())
        {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }
    String nextLine() throws IOException
    {
        return bf.readLine();
    }

    int nextInt() throws IOException
    {
        return Integer.parseInt(next());
    }

    long nextLong() throws IOException
    {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException
    {
        return Double.parseDouble(next());
    }
}

public class Day_Fifteen {


    //拓扑排序
    //给定一个包含n个点m条边的有向无环图，求出该图的拓扑序。
    // 若图的拓扑序不唯一，输出任意合法的拓扑序即可。若该图不能拓扑排序，输出−1。
    //输入描述：
    //第一行输入两个整数n,m (1≤n,m≤2⋅10^5)，表示点的个数和边的条数。
    //接下来的m行，每行输入两个整数ui,vi(1≤u,v≤n)，表示ui 到 vi之间有一条有向边。
    //输出描述：
    //若图存在拓扑序，输出一行n个整数，表示拓扑序。否则输出−1。
    //示例1
    //输入：
    //5 4
    //1 2
    //2 3
    //3 4
    //4 5
    //输出：
    //1 2 3 4 5
    //算法思路：
    //拓扑排序裸题：
    //a. 建图；
    //b. ⼊队为 0 的点⼊队；
    //c. 来⼀次层序遍历即可。
    public static PrintWriter out = new PrintWriter(new BufferedWriter(new
            OutputStreamWriter(System.out)));
    public static Read in = new Read();
    public static int n, m;
    public static Map<Integer, List<Integer>> edges = new HashMap<>(); // 存储图
    public static int[] cnt; //统计⼊度信息



    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        n = in.nextInt(); m = in.nextInt();
        cnt = new int[n + 1];
        // 1. 建图
        for(int i = 0; i < m; i++)
        {
            int a = in.nextInt(), b = in.nextInt();
            // a -> b
            cnt[b]++;
            if(!edges.containsKey(a))
            {
                edges.put(a, new ArrayList<>());
            }
            edges.get(a).add(b);
        }
        // 2. 拓扑排序
        Queue<Integer> q = new LinkedList<>();
        for(int i = 1; i <= n; i++)
        {
            if(cnt[i] == 0)
            {
                q.add(i);
            }
        }
        int[] ret = new int[n]; // 统计拓扑排序的结果
        int pos = 0;
        while(!q.isEmpty())
        {
            int t = q.poll();
            ret[pos++] = t;
            for(int a : edges.getOrDefault(t, new ArrayList<>()))
            {
                cnt[a]--;
                if(cnt[a] == 0)
                {
                    q.add(a);
                }
            }
        }
        if(pos == n)
        {
            // 输出结果：输出最后⼀个数的时候，不能有空格
            for(int i = 0; i < n - 1; i++)
            {
                out.print(ret[i] + " ");
            }
            out.println(ret[n - 1]);
        }
        else
        {
            out.println(-1);
        }

        out.close();
    }




    //枚举+二分
    //链接：https://ac.nowcoder.com/acm/problem/229023
    //来源：牛客网
    //dd当上了宣传委员，开始组织迎新晚会，已知班里有n个同学，
    // 每个同学有且仅有一个擅长的声部，把同学们分成恰好m组
    // 为了不搞砸节目，每一组里的同学都必须擅长同一个声部，
    // 当然，不同组同学擅长同一个声部的情况是可以出现的，
    // 毕竟一个声部也可以分成好几个part进行表演，
    // 但是他不希望出现任何一组的人过多，否则可能会导致场地分配不协调，
    // 也就是说，她希望人数最多的小组的人尽可能少，
    // 除此之外，对组内人员分配没有其他要求，她希望你告诉她，这个值是多少，
    // 如果无法顺利安排，请输出-1
    //输入描述:
    //第一行两个数个数n,m(1≤m≤n≤100000)表示人数
    //接下来一行n个数,a[i](1≤a[i]≤n)表示第i个学生的擅长声部
    //输出描述:
    //输出一个数，表示人数最多的小组的人数
    //示例1
    //输入
    //5 3
    //2 2 3 3 3
    //输出
    //2
    public static int q;
    public static int p;
    public static Map<Integer,Integer> hash = new HashMap<>();//统计每种声部的人数

    public static boolean check(int x){//判断最多人数为x时，能否分成m组
        int g = 0;//统计能分成几组
        for (int a: hash.values()) {
            g+=a/x +(a%x == 0 ?0 :1);
        }
        return g<=p;
    }
    public static void main2(String[] args) {
        Scanner s = new Scanner(System.in);
        q = s.nextInt();
        p = s.nextInt();
        int hMax = 0;//所有声部的最大值
        for (int i = 0; i < q; i++) {
            int x = s.nextInt();
            hash.put(x, hash.getOrDefault(x,0) +1);
            hMax = Math.max(hMax,hash.get(x));
        }

        //边界情况
        int k = hash.size();
        if(k > p){
            System.out.println(-1);
        }else{
            // 暴⼒解法
//          for(int i = 1; i <= hmax; i++)
//          {
//              if(check(i))
//              {
//                  System.out.println(i);
//                  break;
//              }
//          }
            // ⼆分解法
            int l = 1, r = hMax;
            while(l < r)
            {
                int mid = (l + r) / 2;
                if(check(mid)) r = mid;
                else l = mid + 1;
            }
            System.out.println(l);
        }
    }



    //平方数
    //链接：https://ac.nowcoder.com/acm/problem/205350
    //来源：牛客网
    //牛妹是一个喜欢完全平方数的女孩子。
    //牛妹每次看到一个数 x，都想求出离 x 最近的完全平方数 y。
    //每次手算太麻烦，所以牛妹希望你能写个程序帮她解决这个问题。
    //形式化地讲，你需要求出一个正整数 y，满足 y 可以表示成a^2
    //（a 是正整数），使得 |x-y| 的值最小。可以证明这样的 y 是唯一的。
    //输入描述:
    //一行，一个整数x (1≤x≤10^12)，表示牛妹询问的数。
    //输出描述:
    //一行，一个整数 y，表示离 x 最近的完全平方数 y。
    //示例1
    //输入
    //5
    //输出
    //4
    //示例2
    //输入
    //7
    //输出
    //9
    public static void main1(String[] args) {
        Scanner s = new Scanner(System.in);
        long x = s.nextLong();
        long y = (long)Math.sqrt(x);
        long y1 = y*y;
        long y2 = (y+1)*(y+1);
        if (x-y1 < y2-x){
            System.out.println(y1);
        }else{
            System.out.println(y2);
        }
    }

}
